package site.wlwsjsx.iot_backend.controller;

import com.auth0.jwt.exceptions.JWTVerificationException;
import com.auth0.jwt.interfaces.DecodedJWT;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.*;
import site.wlwsjsx.iot_backend.dto.EnvHalfHourAggDTO;
import site.wlwsjsx.iot_backend.dto.EnvUploadDTO;
import site.wlwsjsx.iot_backend.dto.LabDetailDTO;
import site.wlwsjsx.iot_backend.entity.UserInfo;
import site.wlwsjsx.iot_backend.service.EnvInfoService;
import site.wlwsjsx.iot_backend.service.UserService;
import site.wlwsjsx.iot_backend.utils.JWTUtil;
import site.wlwsjsx.iot_backend.utils.JsonResultUtil;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/env")
public class EnvInfoController extends BaseController {
    private static final Logger log = LoggerFactory.getLogger(EnvInfoController.class);
    @Resource
    private EnvInfoService envService;

    @Resource
    private UserService userService;

    /**
     * 处理环境信息上传的接口方法
     *
     * @param envUploadDTO 包含上传环境信息的DTO对象，使用@Valid进行参数校验
     * @return 返回JsonResultUtil<Object>类型的响应结果，包含状态码、消息、token和数据
     */
    @PostMapping("/upload")
    public JsonResultUtil<Object> uploadEnvInfo(@Valid @RequestBody EnvUploadDTO envUploadDTO) {
        // 创建JsonResultUtil对象用于封装响应结果
        JsonResultUtil<Object> jsonResultUtil = new JsonResultUtil<>();
        log.info("开始接收工位环境数据"); // 普通业务日志
        // 调用envService的saveEnvData方法保存环境数据
        envService.saveEnvData(envUploadDTO);
        // 设置响应状态码为200，表示请求成功
        jsonResultUtil.setState(200);
        // 设置响应消息为"上传成功"
        jsonResultUtil.setMessage("上传成功");
        // 设置token为null，此接口不需要返回token
        jsonResultUtil.setToken(null);
        // 设置数据为null，此接口不需要返回具体数据
        jsonResultUtil.setData(null);
        log.info("环境数据上传成功");
        // 返回封装好的响应结果
        return jsonResultUtil;
    }

    /**
     * 查询用户信息的接口
     * 使用GET方法请求"/user/query"路径
     * 返回类型为JsonResultUtil<Object>，用于封装返回的JSON数据
     *
     * @return JsonResultUtil<Object> 返回查询结果的对象，目前返回null
     */
    @GetMapping("/user/query")
    public JsonResultUtil<Object> queryEnvInfo() {
        return null;
    }

    /**
     * 管理员查询实验室详情接口
     * 该接口用于管理员查询实验室的详细信息，需要管理员权限认证
     *
     * @param ‘HttpServletRequest’ HTTP请求对象，用于获取请求头中的认证信息
     * @return JsonResultUtil<Object> 包含查询结果或错误信息的JSON响应对象
     */
    @GetMapping("/admin/query")
    public JsonResultUtil<Object> adminQueryEnvInfo(HttpServletRequest request) {
        // 记录请求开始
        log.info("管理员查询实验室详情请求开始");

        JsonResultUtil<Object> jsonResult = new JsonResultUtil<>();

        try {
            // 1. 从请求头获取token
            String token = request.getHeader("Authorization");
            if (token == null || token.isEmpty()) {
                log.warn("管理员查询实验室详情失败：未提供认证令牌");
                return new JsonResultUtil<>(401, "未提供认证令牌", null);
            }

            // 2. 验证token有效性
            log.debug("开始验证JWT令牌");
            DecodedJWT jwt = JWTUtil.verify(token);
            log.debug("JWT令牌验证成功");

            // 3. 从token中获取用户角色
            String role = jwt.getClaim("role").asString();
            log.debug("从令牌中获取用户角色: {}", role);

            // 4. 验证是否为管理员角色
            if (role == null || !role.equals("2")) { // 假设2代表管理员角色
                log.warn("管理员查询实验室详情失败：权限不足，用户角色: {}", role);
                return new JsonResultUtil<>(403, "权限不足，需要管理员权限", null);
            }

            // 5. 执行原查询逻辑
            log.info("开始查询实验室详情，实验室ID: 1");
            LabDetailDTO labDetailDTO = envService.getLabDetail(1);
            if (labDetailDTO == null) {
                log.error("查询实验室详情失败，实验室ID: 1");
                return new JsonResultUtil<>(500, "查询失败，请联系管理员", null);
            }
            log.info("实验室详情查询成功，实验室ID: 1");

            jsonResult.setState(200);
            jsonResult.setMessage("查询成功");
            jsonResult.setToken(null);
            jsonResult.setData(labDetailDTO);
        } catch (JWTVerificationException e) {
            log.error("JWT令牌验证异常: {}", e.getMessage());
            return new JsonResultUtil<>(401, "认证令牌无效或已过期", null);
        } catch (Exception e) {
            log.error("管理员查询实验室详情异常: {}", e.getMessage());
            return new JsonResultUtil<>(500, "查询失败，请联系管理员", null);
        }

        // 记录请求完成
        log.info("管理员查询实验室详情请求完成");
        return jsonResult;
    }

    @GetMapping("/history/{labId}")
    public JsonResultUtil<Object> getEnvHistory(
            @PathVariable Integer labId,
            @RequestParam(defaultValue = "10") Integer count,
            @RequestParam(defaultValue = "30") Integer interval,
            HttpServletRequest request) {
        log.info("开始查询实验室 {} 的环境历史数据，数量：{}，间隔：{}分钟", labId, count, interval);
        JsonResultUtil<Object> jsonResult = new JsonResultUtil<>();
        try {
            // 获取并验证token
            String token = request.getHeader("Authorization");
            if (token == null || token.isEmpty()) {
                log.warn("查询环境历史数据失败：未提供认证令牌");
                return new JsonResultUtil<>(401, "未提供认证令牌", null);
            }

            // 验证token有效性
            DecodedJWT jwt = JWTUtil.verify(token);
            String role = jwt.getClaim("role").asString();
            String username = jwt.getClaim("username").asString();
            if (username == null) {
                log.warn("查询环境历史数据失败：未提供用户名");
                return new JsonResultUtil<>(401, "未提供用户名", null);
            }

            // 验证用户是否存在
            UserInfo userByUsername = userService.findUserByUsername(username);
            if (userByUsername == null) {
                log.warn("查询环境历史数据失败：用户不存在");
                return new JsonResultUtil<>(401, "用户不存在", null);
            }

            // 获取聚合数据
            List<EnvHalfHourAggDTO> history = envService.getEnvHistoryWithInterval(labId, count, interval);

            Map<String, Object> result = new HashMap<>();
            result.put("records", history);

            jsonResult.setState(200);
            jsonResult.setMessage("查询成功");
            jsonResult.setData(result);

            log.info("实验室 {} 环境历史数据查询成功，返回 {} 条记录", labId, history.size());
        } catch (JWTVerificationException e) {
            log.error("JWT令牌验证异常: {}", e.getMessage());
            return new JsonResultUtil<>(401, "认证令牌无效或已过期", null);
        } catch (Exception e) {
            log.error("查询环境历史数据异常: {}", e.getMessage());
            return new JsonResultUtil<>(500, "查询失败，请联系管理员", null);
        }
        return jsonResult;
    }


    /**
     * 处理GET请求的测试方法
     *
     * @param s 需要拼接的字符串参数
     * @return 返回拼接后的字符串
     */
    @GetMapping("/test")
    public String test(String s) {
        // 将输入的字符串s与"Hello, "拼接并返回
        return "Hello, " + s;
    }
}
